home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 010 / blit.arc / PLOT.C < prev    next >
Text File  |  1985-05-09  |  9KB  |  357 lines
  1. /* PLOT/ADDBIT.C @FINEN */
  2.  
  3. /*
  4.  * FILE:         ADDBIT.C
  5.  *
  6.  * SCCS-ID:      @(#)ADDBIT.C  1.5  85/03/24
  7.  *
  8.  * DESCRIPTION: THIS FILE CONTAINS THE ONE FUNCTION ADDBIT WHICH
  9.  *              ADDS A BIT ONTO THE END OF THE CURRENT PLOT LINE.
  10.  *
  11.  * AUTHOR:       SIMON KENYON.
  12.  *
  13.  * HISTORY:      SCK  1.1  83/10/03  CREATED.
  14.  *              SCK   1.2  84/11/29  MADE IT WORK.
  15.  *              SCK   1.3  85/03/04  TIDIED UP FOR RELEASE.
  16.  *              SCK   1.4  85/03/22  FIXED UP GLOBAL VARIABLE DECLARATIONS.
  17.  *              SCK   1.5  85/03/24  CHANGED THE INCLUDE FILES AROUND.
  18.  */
  19.  
  20. #INCLUDE "LAYERS.H"
  21.  
  22. EXTERN INT BITPTR;
  23.  
  24. UNSIGNED SHORT LINE[512];
  25. UNSIGNED SHORT  WORDMASK[] = {
  26.    0X8000, 0X4000, 0X2000, 0X1000,
  27.    0X0800, 0X0400, 0X0200, 0X0100,
  28.    0X0080, 0X0040, 0X0020, 0X0010,
  29.    0X0008, 0X0004, 0X0002, 0X0001
  30. };
  31.  
  32. /*
  33.  * NAME:         ADDBIT
  34.  *
  35.  * DESCRIPTION: ADD A BIT ONTO THE END OF THE CURRENT PLOT LINE.
  36.  *
  37.  * SYNOPSIS:     ADDBIT (BIT)
  38.  *              INT      BIT;
  39.  *
  40.  * GLOBALS:      BITPTR    (R/W)
  41.  *              LINE       (W)
  42.  *              WORDMASK   (R)
  43.  *
  44.  * CALLS:        NOTHING.
  45.  *
  46.  * CALLED BY:    APPEND  (APPEND.C)
  47.  */
  48. ADDBIT (BIT)
  49. INT    BIT;                            /* 0 OR 1 */
  50. {
  51.    INT      WORDIDX;
  52.    INT      BITIDX;
  53.  
  54.    WORDIDX = BITPTR / WORDSIZE;
  55.     BITIDX = BITPTR % WORDSIZE;
  56.    IF (BIT)
  57.        LINE[WORDIDX] |= WORDMASK[BITIDX];
  58.    ELSE
  59.        LINE[WORDIDX] &= ~WORDMASK[BITIDX];
  60.    BITPTR++;
  61. }
  62.  
  63. /* PLOT/APPEND.C @FINEN */
  64.  
  65. /*
  66.  * FILE:         APPEND.C
  67.  *
  68.  * SCCS-ID:      @(#)APPEND.C  1.4  85/03/24
  69.  *
  70.  * DESCRIPTION: THIS FILE CONTAINS THE ONE FUNCTION APPEND WHICH
  71.  *              ADDS SOME MORE BITS TO THE END OF THE PLOT LINE.
  72.  *
  73.  * AUTHOR:       SIMON KENYON.
  74.  *
  75.  * HISTORY:      SCK  1.1  83/10/03  CREATED.
  76.  *              SCK   1.2  84/11/29  MADE IT WORK.
  77.  *              SCK   1.3  85/03/04  TIDIED UP FOR RELEASE.
  78.  *              SCK   1.4  85/03/24  CHANGED THE INCLUDE FILES AROUND.
  79.  */
  80.  
  81. #INCLUDE "LAYERS.H"
  82.  
  83. /*
  84.  * NAME:         APPEND
  85.  *
  86.  * DESCRIPTION: ADD SOME MORE BITS TO THE END OF THE PLOT LINE.
  87.  *
  88.  * SYNOPSIS:     APPEND (BITS, START, END, SIZE)
  89.  *              UNSIGNED SHORT   BITS;
  90.  *              INT      START;
  91.  *              INT      END;
  92.  *              INT      SIZE;
  93.  *
  94.  * GLOBALS:      NONE.
  95.  *
  96.  * CALLS:        ADDBIT   (ADDBIT.C)
  97.  *
  98.  * CALLED BY:    PLOT  (PLOT.C)
  99.  */
  100. APPEND (BITS, START, END, SIZE)
  101. UNSIGNED SHORT BITS;
  102. INT     START;
  103. INT    END;
  104. INT    SIZE;
  105. {
  106.    INT      I;
  107.    INT      J;
  108.  
  109.    FOR (I = START; I <= END; I++)
  110.        FOR (J = 0; J < SIZE; J++)
  111.            IF (BITS & (1 << (WORDSIZE - (I + 1))))
  112.                ADDBIT (1);
  113.            ELSE
  114.                ADDBIT (0);
  115. }
  116. /* PLOT/PLOT.C @FINEN */
  117.  
  118. /*
  119.  * FILE:         PLOT.C
  120.  *
  121.  * SCCS-ID:      @(#)PLOT.C  1.4  85/03/24
  122.  *
  123.  * DESCRIPTION: THIS FILE CONTAINS THE ONE FUNCTION PLOT, WHICH
  124.  *              GIVEN A BITMAP SB, A RECTANGLE R AND A SCALE FACTOR SIZE
  125.  *              CREATE A PLOT FILE SUITABLE FOR THE PRINTRONIX.
  126.  *
  127.  * AUTHOR:       SIMON KENYON.
  128.  *
  129.  * HISTORY:      SCK  1.1  83/10/03  CREATED.
  130.  *              SCK   1.2  84/11/29  MADE IT WORK.
  131.  *              SCK   1.3  85/02/22  TIDIED UP FOR RELEASE.
  132.  *              SCK   1.4  85/03/24  CHANGED THE INCLUDE FILES AROUND.
  133.  */
  134.  
  135. #INCLUDE <STDIO.H>
  136.  
  137. #INCLUDE "LAYERS.H"
  138.  
  139. INT    BITPTR;                         /* BIT POINTER INTO SCAN LINE BEING
  140.                                          CONSTRUCTED */
  141.  
  142. /*
  143.  * NAME:         PLOT
  144.  *
  145.  * DESCRIPTION: GIVEN A BITMAP SB, A RECTANGLE R AND A SCALE FACTOR SIZE
  146.  *              CREATE A PLOT FILE SUITABLE FOR THE PRINTRONIX.
  147.  *
  148.  * SYNOPSIS:     PLOT (SB, R, SIZE)
  149.  *              STRUCT BITMAP   *SB;
  150.  *              STRUCT RECTANGLE     R;
  151.  *              INT      SIZE;
  152.  *
  153.  * GLOBALS:      BITPTR (W)
  154.  *
  155.  * CALLS:        PRINTF        (LIBC)
  156.  *              APPEND         (APPEND.C)
  157.  *              REFORMAT       (REFORMAT.C)
  158.  *              OUTLINE        (OUTLINE.C)
  159.  *
  160.  * CALLED BY:    THIS IS A TOP LEVEL FUNCTION.
  161.  */
  162. PLOT (SB, R, SIZE)
  163. STRUCT BITMAP *SB;
  164. STRUCT RECTANGLE   R;
  165. INT    SIZE;
  166. {
  167.    INT      INDEX;
  168.    INT      DELTA;
  169.    INT      SX;
  170.    INT      SY;
  171.    INT      DX;
  172.    INT      DY;
  173.    INT      W;
  174.    INT      H;
  175.    INT      STARTBITS;
  176.    INT      ENDBITS;
  177.    INT      START;
  178.    INT      END;
  179.    INT      WORD;
  180.    INT      NWORDS;
  181.    INT      SCANLINE;
  182.    INT      LINECOUNT;
  183.    UNSIGNED SHORT   SRCWORD;
  184.  
  185.    W = R.CORNER.X - R.ORIGIN.X;
  186.    H = R.CORNER.Y - R.ORIGIN.Y;
  187.    IF ((W <= 0) || (H <= 0))
  188.         RETURN;
  189.    SX = R.ORIGIN.X;
  190.    SY = R.ORIGIN.Y;
  191.     STARTBITS = SX % WORDSIZE;
  192.    ENDBITS = (SX + W - 1) % WORDSIZE;
  193.    IF (W <= (WORDSIZE - STARTBITS))
  194.        NWORDS = 1;
  195.    ELSE
  196.        NWORDS = (W - (WORDSIZE - STARTBITS) - 1) / WORDSIZE + 2;
  197.    INDEX = (SY - SB -> RECT.ORIGIN.Y) * SB -> WIDTH +
  198.        (SX / WORDSIZE) -
  199.        (SB -> RECT.ORIGIN.X / WORDSIZE);
  200.    DELTA = SB -> WIDTH - NWORDS;
  201. /*
  202.  * GUNGE AT START OF PLOTFILE
  203.  */
  204.    PRINTF ("\N\N\N");
  205.    FOR (SCANLINE = 1; SCANLINE <= H; SCANLINE++) {
  206.    /*
  207.     * GUNGE AT START OF PLOT LINE
  208.     */
  209.        BITPTR = 0;
  210.  
  211.        START = STARTBITS;
  212.        END = WORDSIZE - 1;
  213.        FOR (WORD = 1; WORD <= NWORDS; WORD++) {
  214.            SRCWORD = *(SB -> BASE + INDEX);
  215.             APPEND (SRCWORD, START, END, SIZE);
  216.            INDEX++;
  217.            IF (WORD == (NWORDS - 1)) {
  218.                START = 0;
  219.                 END = ENDBITS;
  220.            }
  221.            ELSE {
  222.                START = 0;
  223.                END = WORDSIZE - 1;
  224.            }
  225.        }
  226.    /*
  227.     * GUNGE AT END OF LINE
  228.     */
  229.        APPEND ((SHORT) 0, 0, 15, 1);   /* KLUDGE (I'M SORRY) */
  230.        REFORMAT ();
  231.        FOR (LINECOUNT = 0; LINECOUNT < SIZE; LINECOUNT++)
  232.            OUTLINE ();
  233.        INDEX += DELTA;
  234.    }
  235. }
  236. /* PLOT/OUTLINE.C @FINEN */
  237.  
  238. /*
  239.  * FILE:         OUTLINE.C
  240.  *
  241.  * SCCS-ID:      @(#)OUTLINE.C  1.4  85/03/24
  242.  *
  243.  * DESCRIPTION: THIS FILE CONTAINS THE ONE FUNCTION OUTLINE WHICH
  244.  *              SENDS THE NEXT OUTPUT LINE TO THE PRINTRONIX PLOTTER.
  245.  *
  246.  * AUTHOR:       SIMON KENYON.
  247.  *
  248.  * HISTORY:      SCK  1.1  83/10/03  CREATED.
  249.  *              SCK   1.2  84/11/29  MADE IT WORK.
  250.  *              SCK   1.3  85/03/04  TIDIED UP FOR RELEASE.
  251.  *              SCK   1.4  85/03/24  CHANGED THE INCLUDE FILES AROUND.
  252.  */
  253.  
  254. #INCLUDE <STDIO.H>
  255.  
  256. #INCLUDE "LAYERS.H"
  257.  
  258. EXTERN INT OUTPTR;
  259. EXTERN UNSIGNED CHAR   OUTLIN[];
  260.  
  261. /*
  262.  * NAME:         OUTLINE
  263.  *
  264.  * DESCRIPTION: SEND THE NEXT OUTPUT LINE TO THE PRINTRONIX PLOTTER.
  265.  *
  266.  * SYNOPSIS:     OUTLINE ()
  267.  *
  268.  * GLOBALS:      OUTPTR  (R)
  269.  *              OUTLIN   (R)
  270.  *
  271.  * CALLS:        PRINTF  (LIBC)
  272.  *
  273.  * CALLED BY:    PLOT  (PLOT.C)
  274.  */
  275. OUTLINE ()
  276. {
  277.    INT      I;
  278.  
  279.    FOR (I = 0; I < (OUTPTR / BYTESIZE); I++)
  280.        PRINTF ("%C", OUTLIN[I]);
  281.    PRINTF ("\N");
  282. }
  283. /* PLOT/REFORMAT.C @FINEN */
  284.  
  285. /*
  286.  * FILE:         REFORMAT.C
  287.  *
  288.  * SCCS-ID:      @(#)REFORMAT.C  1.4  85/03/24
  289.  *
  290.  *  DESCRIPTION: THIS FILE CONTAINS ONE ROUTINE REFORMAT WHICH
  291.  *              DIDDLES THE BITS IN A PLOT LINE SO THAT THE
  292.  *              PRINTRONIX PRINTER/PLOTTER UNDERSTANDS THEM.
  293.  *
  294.  * AUTHOR:       SIMON KENYON.
  295.  *
  296.  * HISTORY:      SCK  1.1  83/10/03  CREATED.
  297.  *              SCK   1.2  84/11/29  MADE IT WORK.
  298.  *              SCK   1.3  85/03/04  TIDIED UP FOR RELEASE.
  299.  *              SCK   1.4  85/03/24  CHANGED THE INCLUDE FILES AROUND.
  300.  */
  301.  
  302. #INCLUDE "LAYERS.H"
  303.  
  304. EXTERN INT BITPTR;
  305. EXTERN UNSIGNED SHORT   LINE[];
  306. EXTERN UNSIGNED SHORT  WORDMASK[];
  307.  
  308. UNSIGNED SHORT  BYTEMASK[] = {
  309.    0X80, 0X40, 0X20, 0X10,
  310.    0X08, 0X04, 0X02, 0X01
  311. };
  312. UNSIGNED CHAR  OUTLIN[1024];
  313. INT     OUTPTR;
  314.  
  315. /*
  316.  * NAME:         REFORMAT
  317.  *
  318.  * DESCRIPTION: DIDDLE THE BITS IN A PLOT LINE SO THAT THE
  319.  *              PRINTRONIX PRINTER/PLOTTER UNDERSTANDS THEM.
  320.  *
  321.  * SYNOPSIS:     REFORMAT ()
  322.  *
  323.  * GLOBALS:      BITPTR    (R)
  324.  *              LINE       (R)
  325.  *              WORDMASK   (R)
  326.  *              BYTEMASK   (R)
  327.  *              OUTLIN     (W)
  328.  *              OUTPTR     (R/W)
  329.  *
  330.  * CALLS:        NOTHING.
  331.  *
  332.  * CALLED BY:    PLOT  (PLOT.C)
  333.  */
  334. REFORMAT ()
  335. {
  336.    INT      I;
  337.  
  338.  /*
  339.  * NOTE THAT BECAUSE THIS CODE RUNS UNDER PRIMOS
  340.  * THE TOP BIT OF EACH BYTE IS BEING SET
  341.  */
  342.    OUTLIN[0] = 0X85;                   /* THAT'S WHAT THE MAN SAID */
  343.    OUTPTR = 15;
  344.    FOR (I = 0; I < BITPTR; I++) {
  345.        IF (LINE[I / WORDSIZE] & WORDMASK[I % WORDSIZE])
  346.            OUTLIN[OUTPTR / BYTESIZE] |= BYTEMASK[OUTPTR % BYTESIZE];
  347.        ELSE
  348.            OUTLIN[OUTPTR / BYTESIZE] &= ~BYTEMASK[OUTPTR % BYTESIZE];
  349.        IF ((OUTPTR % BYTESIZE) == 2) {
  350.             OUTLIN[OUTPTR / BYTESIZE] |= 0XC0;
  351.            OUTPTR += 13;               /* LEFT AS AN EXERCISE TO THE READER */
  352.        }
  353.        ELSE
  354.            OUTPTR--;
  355.    }
  356. }
  357.